package com.ms3ds.mineInfo.service.impl;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.ms3ds.common.core.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ms3ds.mineInfo.mapper.AlarmMapper;
import com.ms3ds.mineInfo.domain.Alarm;
import com.ms3ds.mineInfo.service.IAlarmService;

/**
 * 告警信息Service业务层处理
 * 
 * @author zlw
 * @date 2025-09-17
 */
@Service
public class AlarmServiceImpl implements IAlarmService 
{
    @Autowired
    private AlarmMapper alarmMapper;

    /**
     * 查询告警信息
     * 
     * @param id 告警信息主键
     * @return 告警信息
     */
    @Override
    public Alarm selectAlarmById(Long id)
    {
        return alarmMapper.selectAlarmById(id);
    }

    /**
     * 查询告警信息列表
     * 
     * @param alarm 告警信息
     * @return 告警信息
     */
    @Override
    public List<Alarm> selectAlarmList(Alarm alarm)
    {
        return alarmMapper.selectAlarmList(alarm);
    }

    /**
     * 新增告警信息
     * 
     * @param alarm 告警信息
     * @return 结果
     */
    @Override
    public int insertAlarm(Alarm alarm)
    {
        alarm.setAlarmTime(DateUtils.getNowDate());
        return alarmMapper.insertAlarm(alarm);
    }

    /**
     * 修改告警信息
     * 
     * @param alarm 告警信息
     * @return 结果
     */
    @Override
    public int updateAlarm(Alarm alarm)
    {
        alarm.setUpdateTime(DateUtils.getNowDate());
        return alarmMapper.updateAlarm(alarm);
    }


    /**
     * 批量删除告警信息
     * 
     * @param ids 需要删除的告警信息主键
     * @return 结果
     */
    @Override
    public int deleteAlarmByIds(Long[] ids)
    {
        return alarmMapper.deleteAlarmByIds(ids);
    }

    /**
     * 删除告警信息信息
     * 
     * @param id 告警信息主键
     * @return 结果
     */
    @Override
    public int deleteAlarmById(Long id)
    {
        return alarmMapper.deleteAlarmById(id);
    }


    /**
     * 根据矿山ID查询告警信息列表，并按规则排序
     *
     * @param mineId 矿山ID
     * @return 告警信息列表（按规则排序）
     */
    @Override
    public List<Alarm> selectAlarmListByMineId(Long mineId) {
        // 创建Alarm对象并设置mineId
        Alarm alarm = new Alarm();
        alarm.setMineId(mineId);

        // 调用原有的selectAlarmList方法获取数据
        List<Alarm> alarmList = alarmMapper.selectAlarmList(alarm);

        // 按照一定规则排序（先按照condition排序，0在前，1在后；然后按照alarmLevel等级排序；最后按照时间倒序排序）
        alarmList.sort((a, b) -> {
            // 先按condition排序，0在前，1在后
            if (a.getCondition() != null && b.getCondition() != null) {
                int conditionCompare = a.getCondition().compareTo(b.getCondition());
                if (conditionCompare != 0) {
                    return conditionCompare;
                }
            } else if (a.getCondition() != null) {
                return -1;
            } else if (b.getCondition() != null) {
                return 1;
            }

            // 再按alarmLevel排序（倒序）
            if (a.getAlarmLevel() != null && b.getAlarmLevel() != null) {
                int levelCompare = b.getAlarmLevel().compareTo(a.getAlarmLevel()); // 交换a和b的位置实现倒序
                if (levelCompare != 0) {
                    return levelCompare;
                }
            } else if (a.getAlarmLevel() != null) {
                return -1;
            } else if (b.getAlarmLevel() != null) {
                return 1;
            }

            // 最后按告警时间倒序排列
            if (a.getAlarmTime() == null && b.getAlarmTime() == null) return 0;
            if (a.getAlarmTime() == null) return 1;
            if (b.getAlarmTime() == null) return -1;
            return b.getAlarmTime().compareTo(a.getAlarmTime());
        });

        return alarmList;
    }



    /**
     * 更新告警状态为已处理
     *
     * @param alarm 包含告警ID和新状态的告警对象
     * @return 结果信息
     */
    @Override
    public int updateAlarmCondition(Alarm alarm) {
        // 查询原始告警信息
        Alarm originalAlarm = alarmMapper.selectAlarmById(alarm.getId());

        // 验证告警是否存在
        if (originalAlarm == null) {
            throw new RuntimeException("告警信息不存在");
        }

        // 验证condition是否为"0"
        if (!"0".equals(originalAlarm.getCondition())) {
            throw new RuntimeException("无效处理，已为已处理状态");
        }

        // 设置更新时间和状态
        alarm.setUpdateTime(DateUtils.getNowDate());
        alarm.setCondition("1");

        // 更新数据库
        return alarmMapper.updateAlarm(alarm);
    }

    /**
     * 统计不同类型告警的数量
     *
     * @param alarm 查询条件
     * @return 包含各类告警数量的Map
     */
    @Override
    public Map<String, Integer> countAlarmTypes(Alarm alarm) {
        // 调用selectAlarmList函数获取数据
        List<Alarm> alarmList = alarmMapper.selectAlarmList(alarm);

        // 初始化计数器
        int vehicle = 0;   // alarmType值为2的数量
        int people = 0;    // alarmType值为3的数量
        int camera = 0;    // alarmType值为4的数量
        int setting = 0;   // alarmType值为其他值的数量

        // 遍历统计
        for (Alarm item : alarmList) {
            if (item.getAlarmType() != null) {
                switch (item.getAlarmType().intValue()) {
                    case 2:
                        vehicle++;
                        break;
                    case 3:
                        people++;
                        break;
                    case 4:
                        camera++;
                        break;
                    default:
                        setting++;
                        break;
                }
            } else {
                setting++;
            }
        }

        // 构造返回结果
        Map<String, Integer> result = new HashMap<>();
        result.put("vehicle", vehicle);
        result.put("people", people);
        result.put("camera", camera);
        result.put("setting", setting);

        return result;
    }

}
